home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Peter Lewis / PNL Libraries / TCPTypes.p < prev    next >
Encoding:
Text File  |  1994-08-27  |  14.5 KB  |  641 lines  |  [TEXT/PJMM]
  1. unit TCPTypes;
  2.  
  3. { TCPTypes © Peter Lewis, Oct 1991 }
  4. { This source is Freeware }
  5.  
  6. interface
  7.  
  8. {$IFC undefined THINK_Pascal}
  9.     uses
  10.         Types, OSUtils;
  11. {$ENDC}
  12.  
  13. { MacTCP return Codes in the range -23000 through -23049 }
  14.     const
  15.         inProgress = 1;                            { I/O in progress }
  16.  
  17.         ipBadLapErr = -23000;                    { bad network configuration }
  18.         ipBadCnfgErr = -23001;                { bad IP configuration error }
  19.         ipNoCnfgErr = -23002;                    { missing IP or LAP configuration error }
  20.         ipLoadErr = -23003;                    { error in MacTCP load }
  21.         ipBadAddrErr = -23004;                    { error in getting address }
  22.         connectionClosingErr = -23005;            { connection is closing }
  23.         invalidLengthErr = -23006;
  24.         connectionExistsErr = -23007;            { request conflicts with existing connection }
  25.         connectionDoesntExistErr = -23008;        { connection does not exist }
  26.         insufficientResourcesErr = -23009;        { insufficient resources to perform request }
  27.         invalidStreamPtrErr = -23010;
  28.         streamAlreadyOpenErr = -23011;
  29.         connectionTerminatedErr = -23012;
  30.         invalidBufPtrErr = -23013;
  31.         invalidRDSErr = -23014;
  32.         invalidWDSErr = -23014;
  33.         openFailedErr = -23015;
  34.         commandTimeoutErr = -23016;
  35.         duplicateSocketErr = -23017;
  36.  
  37. { Error codes from internal IP functions }
  38.         ipDontFragErr = -23032;                { Packet too large to send w/o fragmenting }
  39.         ipDestDeadErr = -23033;                { destination not responding }
  40.         icmpEchoTimeoutErr = -23035;        { ICMP echo timed-out }
  41.         ipNoFragMemErr = -23036;            { no memory to send fragmented pkt }
  42.         ipRouteErr = -23037;                    { can't route packet off-net }
  43.  
  44.         nameSyntaxErr = -23041;
  45.         cacheFaultErr = -23042;
  46.         noResultProcErr = -23043;
  47.         noNameServerErr = -23044;
  48.         authNameErrErr = -23045;
  49.         noAnsErr = -23046;
  50.         dnrErr = -23047;
  51.         outOfMemoryErr = -23048;
  52.  
  53. { connectionState }
  54.     const
  55.         CState_Closed = 0;
  56.         CState_Listening = 2;
  57.         CState_Opening1 = 4;
  58.         CState_Opening2 = 6;
  59.         CState_Established = 8;
  60.         CState_Closing1 = 10;
  61.         CState_Closing2 = 12;
  62.         CState_Closing3 = 16;
  63.         CState_Closing4 = 18;
  64.         CState_Closing5 = 20;
  65.         CState_PleaseClose = 14;
  66.  
  67.     type
  68.         AddrClasses = integer;
  69.     const
  70.         AC_A = 1;
  71.         AC_NS = 2;
  72.         AC_CNAME = 5;
  73.         AC_HINFO = 13;
  74.         AC_MX = 15;
  75.  
  76.     const
  77.         CTRUE = $FF;
  78.         CFALSE = $00;
  79.  
  80.     type
  81.         C_BOOLEAN = signedByte;
  82.         CSTRING = ptr;
  83.         CStr30 = packed array[0..29] of char;
  84.         CStr255 = packed array[0..255] of char;
  85.         ipAddr = longInt;
  86.         ipPort = integer;
  87.         StreamPtr = ptr;
  88.  
  89.     type
  90.         wdsType = record            { Write block for TCP driver. }
  91.                 size: integer;                { Number of bytes. }
  92.                 buffer: Ptr;                { Pointer to bytes. }
  93.                 term: integer;                { Zero for end of blocks. }
  94.             end;
  95.         wdsPtr = ^wdsType;
  96.         wdsEntry = record
  97.                 size: integer;                { Number of bytes. }
  98.                 buffer: Ptr;                { Pointer to bytes. }
  99.             end;
  100.  
  101.         hostInfo = record
  102.                 rtnCode: longInt;
  103.                 rtnHostName: str255;
  104.                 addrs: array[1..4] of ipAddr;
  105.             end;
  106.         hostInfoPtr = ^hostInfo;
  107.  
  108.     type
  109.         HInfoRec = record
  110.                 cpuType: CStr30;
  111.                 osType: CStr30;
  112.             end;
  113.  
  114.     type
  115.         MXRec = record
  116.                 preference: integer; { unsigned! }
  117.                 exchange: CStr255;
  118.             end;
  119.  
  120.     type
  121.         hmxInfoRec = record
  122.                 rtcCode: integer;
  123.                 cname: CStr255;
  124.                 case integer of
  125.                     1: (
  126.                             addr: array[1..4] of ipAddr;
  127.                     );
  128.                     2: (
  129.                             hinfo: HInfoRec;
  130.                     );
  131.                     3: (
  132.                             mx: MXRec;
  133.                     );
  134.             end;
  135.         hmxInfoRecPtr = ^hmxInfoRec;
  136.  
  137.     type
  138.         cacheEntryRecord = record
  139.                 cname: CSTRING;
  140.                 typ: integer;
  141.                 class: integer;
  142.                 ttl: longInt;
  143.                 case integer of
  144.                     1: (
  145.                             name: CSTRING;
  146.                     );
  147.                     2: (
  148.                             addr: ipAddr;
  149.                     );
  150.             end;
  151.         cacheEntryRecordPtr = ^cacheEntryRecord;
  152.  
  153.     const { csCodes for the TCP driver: }
  154.         TCPcsGetMyIP = 15;
  155.         TCPcsEchoICMP = 17;
  156.         TCPcsLAPStats = 19;
  157.         TCPcsCreate = 30;
  158.         TCPcsPassiveOpen = 31;
  159.         TCPcsActiveOpen = 32;
  160. {    TCPcsActOpenWithData = 33;}
  161.         TCPcsSend = 34;
  162.         TCPcsNoCopyRcv = 35;
  163.         TCPcsRcvBfrReturn = 36;
  164.         TCPcsRcv = 37;
  165.         TCPcsClose = 38;
  166.         TCPcsAbort = 39;
  167.         TCPcsStatus = 40;
  168.         TCPcsExtendedStat = 41;
  169.         TCPcsRelease = 42;
  170.         TCPcsGlobalInfo = 43;
  171.  
  172.         UDPcsCreate = 20;
  173.         UDPcsRead = 21;
  174.         UDPcsBfrReturn = 22;
  175.         UDPcsWrite = 23;
  176.         UDPcsRelease = 24;
  177.         UDPcsMaxMTUSize = 25;
  178.         UDPcsStatus = 26;
  179.         UDPcsMultiCreate = 27;
  180.         UDPcsMultiSend = 28;
  181.         UDPcsMultiRead = 29;
  182.  
  183.     type
  184.         TCPEventCode = integer;
  185.     const
  186.         TEC_Closing = 1;
  187.         TEC_ULPTimeout = 2;
  188.         TEC_Terminate = 3;
  189.         TEC_DataArrival = 4;
  190.         TEC_Urgent = 5;
  191.         TEC_ICMPReceived = 6;
  192.         TEC_last = 32767;
  193.  
  194.     type
  195.         UDPEventCode = integer;
  196.     const
  197.         UDPDataArrival = 1;
  198.         UDPICMPReceived = 2;
  199.         lastUDPEvent = 32767;
  200.  
  201.     type
  202.         TCPTerminateReason = integer;
  203.     const {TCPTerminateReasons: }
  204.         TTR_RemoteAbort = 2;
  205.         TTR_NetworkFailure = 3;
  206.         TTR_SecPrecMismatch = 4;
  207.         TTR_ULPTimeoutTerminate = 5;
  208.         TTR_ULPAbort = 6;
  209.         TTR_ULPClose = 7;
  210.         TTR_ServiceError = 8;
  211.         TTR_last = 32767;
  212.  
  213.     type
  214.         ICMPMsgType = integer;
  215.     const
  216.         ICMP_NetUnreach = 0;
  217.         ICMP_HostUnreach = 1;
  218.         ICMP_ProtocolUnreach = 2;
  219.         ICMP_PortUnreach = 3;
  220.         ICMP_FragReqd = 4;
  221.         ICMP_SourceRouteFailed = 5;
  222.         ICMP_TimeExceeded = 6;
  223.         ICMP_ParmProblem = 7;
  224.         ICMP_MissingOption = 8;
  225.  
  226.     type
  227.         TCPNotifyProc = procPtr;
  228. { procedure TCPNotifyProc(tcpStream:StreamPtr; event:TCPEventCode; userDataPtr:ptr; }
  229. {                                   terminReason:TCPTerminateReason; icmpMsg:ICMPReportPtr); }
  230.  
  231.     type
  232.         TCPIOCompletionProc = procPtr;
  233. { C procedure TCPIOCompletionProc(iopb:TCPControlBlockPtr); - WHY IS THIS A C PROC???? }
  234.  
  235.     type
  236.         UDPNotifyProc = procPtr;
  237. { procedure UDPProc(udpStream:StreamPtr ; eventCode:integer;userDataPtr:ptr; icmpMsg:ICMPReportPtr) }
  238.  
  239.     type
  240.         UDPIOCompletionProc = procPtr;
  241. { C procedure UDPIOCompletionProc(iopb:UDPiopb Ptr) }
  242.  
  243.     type
  244.         ICMPEchoNotifyProc = ProcPtr;
  245. { C procedure ICMPEchoNotifyProc(iopb:IPControlBlockPtr) }
  246. { WARNING: Ignore the docs, its a C proceudre no matter what they say }
  247.  
  248.     type
  249.         ICMPReport = record
  250.                 stream: StreamPtr;
  251.                 localHost: ipAddr;
  252.                 localPort: ipPort;
  253.                 remoteHost: ipAddr;
  254.                 remotePort: ipPort;
  255.                 reportType: ICMPMsgType;
  256.                 optionalAddlInfo: integer;
  257.                 optionalAddlInfoPtr: ptr;
  258.             end;
  259.  
  260.     const
  261.         NBP_TABLE_SIZE = 20;            { number of NBP table entries }
  262.         NBP_MAX_NAME_SIZE = 16 + 10 + 2;
  263.         ARP_TABLE_SIZE = 20;            { number of ARP table entries }
  264.  
  265.     type
  266.         nbpEntry = record
  267.                 ip_address: ipAddr;                { IP address }
  268.                 at_address: longInt;                { matching AppleTalk address }
  269.                 gateway: Boolean;                { TRUE if entry for a gateway }
  270.                 valid: Boolean;                    { TRUE if LAP address is valid }
  271.                 probing: Boolean;                { TRUE if NBP lookup pending }
  272.                 age: integer;                    { ticks since cache entry verified }
  273.                 access: integer;                    { ticks since last access }
  274.                 filler: packed array[1..116] of byte;            { for internal use only !!! }
  275.             end;
  276.         EnetAddr = record
  277.                 en_hi: integer;
  278.                 en_lo: longInt;
  279.             end;
  280.         arpEntry = record
  281.                 age: integer;            { cache aging field }
  282.                 protocol: integer;        { Protocol type }
  283.                 ip_address: ipAddr;        { IP address }
  284.                 en_address: EnetAddr;        { matching Ethernet address }
  285.             end;
  286.         AddrXlation = record
  287.                 case integer of
  288.                     0: (
  289.                             arp_table: ^arpEntry
  290.                     );
  291.                     1: (
  292.                             nbp_entry: ^nbpEntry
  293.                     )
  294.             end;
  295.         LAPStats = record
  296.                 ifType: integer;
  297.                 ifString: CSTRING;
  298.                 ifMaxMTU: integer;
  299.                 ifSpeed: longInt;
  300.                 ifPhyAddrLength: integer;
  301.                 ifPhysicalAddress: CSTRING;
  302.                 addr: AddrXlation;
  303.                 slotNumber: integer;
  304.             end;
  305.         IPEchoPB = record
  306.                 dest: ipAddr;                { echo to IP address }
  307.                 data: wdsEntry;
  308.                 timeout: integer;
  309.                 options: Ptr;
  310.                 optLength: integer;
  311.                 icmpCompletion: ICMPEchoNotifyProc;
  312.                 userDataPtr: ptr;
  313.             end;
  314.         LAPStatsPB = record
  315.                 lapStatsPtr: ^LAPStats;
  316.             end;
  317.         ICMPEchoInfo = record
  318.                 params: array[1..11] of integer;
  319.                 echoRequestOut: longInt;    { time in ticks of when the echo request went out }
  320.                 echoReplyIn: longInt;        { time in ticks of when the reply was received }
  321.                 data: wdsEntry;        { data received in responce }
  322.                 options: ptr;
  323.                 userDataPtr: ptr;
  324.             end;
  325.         IPGetMyIPPB = record
  326.                 ourAddress: ipAddr;            { our IP address }
  327.                 ourNetMask: ipAddr;            { our IP net mask }
  328.             end;
  329.  
  330.         IPControlBlock = record
  331.                 qLink: QElemPtr;
  332.                 qType: INTEGER;
  333.                 ioTrap: INTEGER;
  334.                 ioCmdAddr: Ptr;
  335.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  336.                 ioResult: OSErr; {result code}
  337.                 ioNamePtr: StringPtr;
  338.                 ioVRefNum: INTEGER;
  339.                 ioCRefNum: INTEGER; {device refnum}
  340.                 case csCode : integer of
  341.                     TCPcsGetMyIP: (
  342.                             getmyip: IPGetMyIPPB;
  343.                     );
  344.                     TCPcsEchoICMP: (
  345.                             echo: IPEchoPB
  346.                     );
  347.                     9999: (
  348.                             echoinfo: ICMPEchoInfo
  349.                     );
  350.                     TCPcsLAPStats: (
  351.                             lapstat: LAPStatsPB
  352.                     );
  353.             end;
  354.         IPControlBlockPtr = ^IPControlBlock;
  355.  
  356.     type
  357.         UDPCreatePB = record { for create and release calls }
  358.                 rcvBuff: Ptr;
  359.                 rcvBuffLen: longInt;
  360.                 notifyProc: UDPNotifyProc;
  361.                 localport: ipPort;
  362.                 userDataPtr: ptr;
  363.                 endingPort: ipPort;
  364.             end;
  365.  
  366.     type
  367.         UDPSendPB = record
  368.                 reserved: integer;
  369.                 remoteIP: ipAddr;
  370.                 remotePort: ipPort;
  371.                 wds: wdsPtr;
  372.                 checkSum: signedByte;
  373.                 sendLength: integer;
  374.                 userDataPtr: ptr;
  375.                 localPort: ipPort;
  376.             end;
  377.  
  378.     type
  379.         UDPReceivePB = record
  380.                 timeOut: integer;
  381.                 remoteIP: ipAddr;
  382.                 remotePort: ipPort;
  383.                 rcvBuff: ptr;
  384.                 rcvBuffLen: integer;
  385.                 secondTimeStamp: integer;
  386.                 userDataPtr: ptr;
  387.                 destHost: ipAddr;
  388.                 destPort: ipPort;
  389.             end;
  390.  
  391.     type
  392.         UDPMTUPB = record
  393.                 mtuSize: integer;
  394.                 remoteIP: ipAddr;
  395.                 userDataPtr: ptr;
  396.             end;
  397.  
  398.     type
  399.         UDPControlBlock = record
  400.                 qLink: QElemPtr;
  401.                 qType: INTEGER;
  402.                 ioTrap: INTEGER;
  403.                 ioCmdAddr: Ptr;
  404.                 ioCompletion: UDPIOCompletionProc;
  405.                 ioResult: OSErr;
  406.                 ioNamePtr: stringPtr;
  407.                 ioVRefNum: integer;
  408.                 ioCRefNum: integer;
  409.                 csCode: integer;
  410.                 udpStream: streamPtr;
  411.                 case integer of
  412.                     UDPcsCreate, UDPcsMultiCreate, UDPcsRelease: (
  413.                             create: UDPCreatePB
  414.                     );
  415.                     UDPcsWrite, UDPcsMultiSend: (
  416.                             send: UDPSendPB
  417.                     );
  418.                     UDPcsRead, UDPcsMultiRead: (
  419.                             receive: UDPReceivePB
  420.                     );
  421.                     UDPcsBfrReturn: (
  422.                             return: UDPReceivePB
  423.                     );
  424.                     UDPcsMaxMTUSize: (
  425.                             mtu: UDPMTUPB
  426.                     );
  427.             end;
  428.         UDPControlBlockPtr = ^UDPControlBlock;
  429.  
  430.     const { Validity Flags }
  431.         timeOutValue = $80;
  432.         timeOutAction = $40;
  433.         typeOfService = $20;
  434.         precedence = $10;
  435.  
  436.     const { TOSFlags }
  437.         lowDelay = $01;
  438.         throughPut = $02;
  439.         reliability = $04;
  440.  
  441.     type
  442.         TCPCreatePB = packed record
  443.                 rcvBuff: ptr;
  444.                 rcvBuffLen: longInt;
  445.                 notifyProc: TCPNotifyProc;
  446.                 userDataPtr: ptr;
  447.             end;
  448.  
  449.         TCPOpenPB = packed record
  450.                 ulpTimeoutValue: byte;
  451.                 ulpTimeoutAction: signedByte;
  452.                 validityFlags: byte;
  453.                 commandTimeoutValue: byte;
  454.                 remoteHost: ipAddr;
  455.                 remotePort: ipPort;
  456.                 localHost: ipAddr;
  457.                 localPort: ipPort;
  458.                 tosFlags: byte;
  459.                 precedence: byte;
  460.                 dontFrag: C_BOOLEAN;
  461.                 timeToLive: byte;
  462.                 security: byte;
  463.                 optionCnt: byte;
  464.                 options: array[0..39] of byte;
  465.                 userDataPtr: ptr;
  466.             end;
  467.  
  468.         TCPSendPB = packed record
  469.                 ulpTimeoutValue: byte;
  470.                 ulpTimeoutAction: signedByte;
  471.                 validityFlags: byte;
  472.                 pushFlag: byte;
  473.                 urgentFlag: C_BOOLEAN;
  474.                 wds: wdsptr;
  475.                 sendFree: longInt;
  476.                 sendLength: integer;
  477.                 userDataPtr: ptr;
  478.             end;
  479.  
  480.         TCPReceivePB = packed record
  481.                 commandTimeoutValue: byte;
  482.                 filler: byte;
  483.                 markFlag: C_BOOLEAN;
  484.                 urgentFlag: C_BOOLEAN;
  485.                 rcvBuff: ptr;
  486.                 rcvBuffLength: integer;
  487.                 rdsPtr: ptr;
  488.                 rdsLength: integer;
  489.                 secondTimeStamp: integer;
  490.                 userDataPtr: ptr;
  491.             end;
  492.  
  493.         TCPClosePB = packed record
  494.                 ulpTimeoutValue: byte;
  495.                 ulpTimeoutAction: signedByte;
  496.                 validityFlags: byte;
  497.                 userDataPtrX: ptr;   { Thats mad!  Its not on a word boundary! Parhaps a documentation bug??? }
  498.             end;
  499.  
  500.         HistoBucket = packed record
  501.                 value: integer;
  502.                 counter: longInt;
  503.             end;
  504.  
  505.     const
  506.         NumOfHistoBuckets = 7;
  507.  
  508.     type
  509.         TCPConnectionStats = packed record
  510.                 dataPktsRcvd: longInt;
  511.                 dataPktsSent: longInt;
  512.                 dataPktsResent: longInt;
  513.                 bytesRcvd: longInt;
  514.                 bytesRcvdDup: longInt;
  515.                 bytesRcvdPastWindow: longInt;
  516.                 bytesSent: longInt;
  517.                 bytesResent: longInt;
  518.                 numHistoBuckets: integer;
  519.                 sentSizeHisto: array[1..NumOfHistoBuckets] of HistoBucket;
  520.                 lastRTT: integer;
  521.                 tmrRTT: integer;
  522.                 rttVariance: integer;
  523.                 tmrRTO: integer;
  524.                 sendTries: byte;
  525.                 sourceQuenchRcvd: byte;
  526.             end;
  527.         TCPConnectionStatsPtr = ^TCPConnectionStats;
  528.  
  529.         TCPStatusPB = packed record
  530.                 ulpTimeoutValue: byte;
  531.                 ulpTimeoutAction: signedByte;
  532.                 unused: longInt;
  533.                 remoteHost: ipAddr;
  534.                 remotePort: ipPort;
  535.                 localHost: ipAddr;
  536.                 localPort: ipPort;
  537.                 tosFlags: byte;
  538.                 precedence: byte;
  539.                 connectionState: byte;
  540.                 filler: byte;
  541.                 sendWindow: integer;
  542.                 rcvWindow: integer;
  543.                 amtUnackedData: integer;
  544.                 amtUnreadData: integer;
  545.                 securityLevelPtr: ptr;
  546.                 sendUnacked: longInt;
  547.                 sendNext: longInt;
  548.                 congestionWindow: longInt;
  549.                 rcvNext: longInt;
  550.                 srtt: longInt;
  551.                 lastRTT: longInt;
  552.                 sendMaxSegSize: longInt;
  553.                 connStatPtr: TCPConnectionStatsPtr;
  554.                 userDataPtr: ptr;
  555.             end;
  556.  
  557.         TCPAbortPB = packed record
  558.                 userDataPtr: ptr;
  559.             end;
  560.  
  561.         TCPParam = packed record
  562.                 tcpRTOA: StringPtr;
  563.                 tcpRTOMin: longInt;
  564.                 tcpRTOMax: longInt;
  565.                 tcpMaxSegSize: longInt;
  566.                 tcpMaxConn: longInt;
  567.                 tcpMaxWindow: longInt;
  568.             end;
  569.         TCPParamPtr = ^TCPParam;
  570.  
  571.         TCPStats = packed record
  572.                 tcpConnAttempts: longInt;
  573.                 tcpConnOpened: longInt;
  574.                 tcpConnAccepted: longInt;
  575.                 tcpConnClosed: longInt;
  576.                 tcpConnAborted: longInt;
  577.                 tcpOctetsIn: longInt;
  578.                 tcpOctetsOut: longInt;
  579.                 tcpOctetsInDup: longInt;
  580.                 tcpOctetsRetrans: longInt;
  581.                 tcpInputPackets: longInt;
  582.                 tcpOutputPkts: longInt;
  583.                 tcpDupPkts: longInt;
  584.                 tcpRetransPkts: longInt;
  585.             end;
  586.         TCPStatsPtr = ^TCPStats;
  587.  
  588.         StreamPtrArray = array[1..1000] of StreamPtr;
  589.         StreamPtrArrayPtr = ^StreamPtrArray;
  590.  
  591.         TCPGlobalInfoPB = packed record
  592.                 tcpParamp: TCPParamPtr;
  593.                 tcpStatsp: TCPStatsPtr;
  594.                 tcpCDBTable: StreamPtrArrayPtr;
  595.                 userDataPtr: ptr;
  596.                 maxTCPConnections: integer;
  597.             end;
  598.  
  599.         TCPControlBlock = record
  600.                 qLink: QElemPtr;
  601.                 qType: INTEGER;
  602.                 ioTrap: INTEGER;
  603.                 ioCmdAddr: Ptr;
  604.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  605.                 ioResult: OSErr; {result code}
  606.                 ioNamePtr: StringPtr;
  607.                 ioVRefNum: INTEGER;
  608.                 ioCRefNum: INTEGER; {device refnum}
  609.                 csCode: integer;
  610.                 tcpStream: StreamPtr;
  611.                 case integer of
  612.                     TCPcsCreate: (
  613.                             create: TCPCreatePB
  614.                     );
  615.                     TCPcsActiveOpen, TCPcsPassiveOpen: (
  616.                             open: TCPOpenPB;
  617.                     );
  618.                     TCPcsSend: (
  619.                             send: TCPSendPB;
  620.                     );
  621.                     TCPcsNoCopyRcv, TCPcsRcvBfrReturn, TCPcsRcv: (
  622.                             receive: TCPReceivePB;
  623.                     );
  624.                     TCPcsClose: (
  625.                             close: TCPClosePB;
  626.                     );
  627.                     TCPcsAbort: (
  628.                             abort: TCPAbortPB;
  629.                     );
  630.                     TCPcsStatus: (
  631.                             status: TCPStatusPB;
  632.                     );
  633.                     TCPcsGlobalInfo: (
  634.                             globalInfo: TCPGlobalInfoPB
  635.                     );
  636.             end;
  637.         TCPControlBlockPtr = ^TCPControlBlock;
  638.  
  639. implementation
  640.  
  641. end.